/*
 * Archivos.java
 *
 * Created on 7 de mayo de 2007, 13:27
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package util;

import bd.ConexionAvw;
import com.sun.image.codec.jpeg.*;
import excepciones.AvwException;
import java.awt.*;
import java.awt.image.*;

import excepciones.AvwException;
import java.io.*;
import java.net.*;
import java.nio.channels.FileChannel;
import java.sql.ResultSet;
import java.util.Iterator;
import java.util.StringTokenizer;

import java.util.logging.Level;
import java.util.logging.Logger;

import javax.servlet.*;
import javax.servlet.http.*;
import util.FuncionServlets;
import java.util.Iterator;
import java.util.List;

import javax.servlet.http.*;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import util.Recurso;
import util.Utiles;

/**
 *
 * @author Administrador
 */
public class Archivos {
    static final Logger logger = Utiles.iniciarLogger("ArticuloAdmin", false);
    
    /**
     * Copia TODO el directorio (archivos y carpetas) origen,
     * al directorio destino.
     * @param:
     *      srcPath: origen.
     *      dstPath: destino.
     **/
    public static void copiarDirectorio(File srcPath, File dstPath) throws IOException{
        if (srcPath.isDirectory()) {
            if (!dstPath.exists()) {
                dstPath.mkdir();
            }
            
            String files[] = srcPath.list();
            for(int i = 0; i < files.length; i++) {
                copiarDirectorio(new File(srcPath, files[i]), new File(dstPath, files[i]));
            }
        } else {
            if(!srcPath.exists()) {
                System.out.println("El archivo o el directorio no existe.");
                System.exit(0);
            } else {
                InputStream in = new FileInputStream(srcPath);
                OutputStream out = new FileOutputStream(dstPath);
                
                // Transfer bytes from in to out
                byte[] buf = new byte[1024];
                int len;
                while ((len = in.read(buf)) > 0) {
                    out.write(buf, 0, len);
                }
                in.close();
                out.close();
            }
        }
        System.out.println("Directorio copiado.");
    }
    
    /**
     * Borra TODO el directorio (archivos y carpetas) pasado por parametro.
     * @param: srcPath directorio a borrar.
     **/
    public static void borrarDirectorio(File srcPath) throws IOException{
        if (srcPath.isDirectory()) {
            String files[] = srcPath.list();
            for(int i = 0; i < files.length; i++) {
                borrarDirectorio(new File(srcPath, files[i]));
            }
        } else {
            srcPath.delete();
        }
    }
    
    /**
     * Copia el archivo fuente al archivo destino.
     * @param srcFile: archivo fuente.
     * @param dstFile: archivo destino.
     **/
    public static void copiarArchivos(File srcFile, File dstFile) throws IOException{
        FileInputStream fis = new FileInputStream(srcFile);
        FileOutputStream fos = new FileOutputStream(dstFile);
        FileChannel canalFuente = fis.getChannel();
        FileChannel canalDestino = fos.getChannel();
        canalFuente.transferTo(0, canalFuente.size(), canalDestino);
        fis.close();
        fos.close();
    }
    
    /**
     * Sube/graba al servidor el archivo pasado a traves del request.
     * @lib
     * --- Libreria necesaria: 'org.apache.commons.fileupload' ---
     * @param request: contiene un form (enctype="multipart/form-data") que contiene
     * un input (type="file").
     * @param nombreFile: Nombre del input (type="file") del formulario
     * que contiene el request.
     * @param dirArchivos: directorio destino del archivo a subir.
     * @param srcArchivo: nombre del archivo a subir.
     **/
    public static boolean upload(HttpServletRequest request, String nombreFile, String dirArchivo, String dstArchivo){
        FileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
        PrintWriter out = null;
        List items = null;
        boolean resultado = false;
        
        logger.info("Intenta upload");
        try {
            items = upload.parseRequest(request);
            logger.info("Crea el item");
        } catch (FileUploadException ex) {
            ex.printStackTrace();
            logger.info("Exception: "+ex.getMessage());
        }
        
        if (items != null){
            Iterator iter = items.iterator();
            logger.info("Crea el iterator para recorrer el item");
            while (iter.hasNext()) {
                FileItem item = (FileItem) iter.next();
                String fieldName = item.getFieldName();
                logger.info("Fieldname: "+fieldName);
                String fileName = item.getName();
                logger.info("Filename: "+fileName);
                String contentType = item.getContentType();
                if (!item.isFormField()) {
                    logger.info("El item NO es un campo del formulario, es un file");
                    boolean isInMemory = item.isInMemory();
                    long sizeInBytes = item.getSize();
                    if(sizeInBytes!=0){
                        File uploadedFile = null;
                        if (fieldName.equals(nombreFile)){
                            String nombreArchivo = dstArchivo + "." + obtenerExtension(item.getName());
                            if (dstArchivo == null){
                              nombreArchivo = fileName;  
                            }
                            logger.info("Crea el archivo "+nombreArchivo+" en el dir: "+dirArchivo);
                            uploadedFile = new File(dirArchivo,nombreArchivo);
                            logger.info("Creacion OK");
                        }
                        try {
                            item.write(uploadedFile);
                            resultado = true;
                            
                            /*
                            String nombreFuente = uploadedFile.getParent()+"/"+uploadedFile.getName();
                            String nombreDestino = uploadedFile.getParent()+"/"+srcArchivo+"_alta."+obtenerExtension(uploadedFile.getName());
                             
                            copiarArchivos(uploadedFile,new File(nombreDestino));
                             
                            File destino = new File(nombreDestino);
                            dimesionarImagen(uploadedFile,uploadedFile.getPath(),"baja");
                            dimesionarImagen(destino,destino.getPath(),"alta");
                             */
                        } catch (Exception ex) {
                            ex.printStackTrace();
                            logger.info("Exception: "+ex.getMessage());
                            resultado = false;
                        }
                    }
                }   // fin if (!item.isFormField())
            }   // while (iter.hasNext())
        }   //if (items != null)
        logger.info("FIN UPLOAD");
        return resultado;
    }
    
    /**
     * Verifica la extension del nombre de archivo pasado por parametro
     * con respecto al filtro tambien pasado por parametro.
     **/
    public static boolean verificarExtension(String nombreFile, String filtrosArchivo){
        logger.info("Verifica extension");
        String prop = "";
        String ext = obtenerExtension(nombreFile);
        
        prop = filtrosArchivo;
        String filtros[] = prop.split(",");
        
        for (int i=0; i<filtros.length; i++){
            if (ext.equals(filtros[i])){
                return true;
            }
        }
        
        return false;
    }
    
    /**
     * Obtiene la extension del nombre de archivo pasado por parametro.
     **/
    public static String obtenerExtension(String nombreFile){
        String ext = "";
        nombreFile = nombreFile;
        StringTokenizer st = new StringTokenizer(nombreFile, ".");
        if (st.countTokens() > 1)
            while(st.hasMoreTokens())
                ext = st.nextToken();
        
        return ext;
    }
    
    /**
     * Busca el archivo con el nombre y la ruta especificada.
     * Devuelve el nombre del archivo.
     **/
    public static String obtenerNombreArchivo(String nombreBuscar, String path){
        File fichero = new File(path);
        String[] listaArchivos = fichero.list();
        String nombreArchivo = "";
        for(int i=0; i<listaArchivos.length; i++){
            File archivo = new File(path+"/"+listaArchivos[i]);
            if (archivo.getName().equals(nombreBuscar+"."+obtenerExtension(archivo.getName()))){
                nombreArchivo = listaArchivos[i];
            }
        }
        
        return nombreArchivo;
    }
    
    /**
     * Dimensiona la imagen pasada por parametro y la guarda
     * en la URL especificada.
     * @param File: archivo que contiene la ruta de la imagen.
     * @param Destino: URL en donde se va a guardar la imagen.
     * @param alto: se especifica el alto de la foto.
     * @param ancho: se especifica el ancho de la foto.
     **/
    public static void dimensionarImagen(File file, String destino,  String alto, String ancho) throws Exception{
        // Carga la imagen desde el INFILE
        Image image = Toolkit.getDefaultToolkit().getImage(file.getAbsolutePath());
        MediaTracker mediaTracker = new MediaTracker(new Container());
        mediaTracker.addImage(image, 0);
        mediaTracker.waitForID(0);
        
        // Determina  el tamanio del desde el WIDTH and HEIGHT thumbnail
        // se especifica a traves de las variables alto y ancho.
        int thumbWidth = 0;
        int thumbHeight = 0;
        if (ancho.equals("") || alto.equals("")){
            thumbWidth = image.getWidth(null);
            thumbHeight = image.getHeight(null);
        }else{
            thumbWidth = Integer.parseInt(ancho);
            thumbHeight = Integer.parseInt(alto);
        }
        
        
        //Compara el ancho y el alto de la foto con el alto y ancho especificado
        double thumbRatio = (double)thumbWidth / (double)thumbHeight;
        int imageWidth = image.getWidth(null);
        int imageHeight = image.getHeight(null);
        double imageRatio = (double)imageWidth / (double)imageHeight;
        
        //Achico el alto o el ancho de la imagen si fuera necesario
        if (thumbRatio < imageRatio) {
            thumbHeight = (int)(thumbWidth / imageRatio);
        } else {
            thumbWidth = (int)(thumbHeight * imageRatio);
        }
        
        /*
         * Dibuja la imagen original a un objeto imagen thumbnail
         * lo escala a la nueva dimension on-the-fly
         */
        BufferedImage thumbImage = new BufferedImage(thumbWidth,
                thumbHeight, BufferedImage.TYPE_INT_RGB);
        Graphics2D graphics2D = thumbImage.createGraphics();
        graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                RenderingHints.VALUE_INTERPOLATION_BILINEAR);
        graphics2D.drawImage(image, 0, 0, thumbWidth, thumbHeight, null);
        
        // Guarda la imagen thumbnail a un OUTFILE
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(destino));
        
        //Parsea la foto a jpeg
        JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
        JPEGEncodeParam param = encoder.
                getDefaultJPEGEncodeParam(thumbImage);
        
        //Se especifica la calidad de la imagen
        int quality = 999999999;
        quality = Math.max(0, Math.min(quality, 100));
        param.setQuality((float)quality / 100.0f, false);
        encoder.setJPEGEncodeParam(param);
        encoder.encode(thumbImage);
        out.close();
    }
    public void dimensionarTodasLasImagenes() throws Exception{
        StringBuilder sql = new StringBuilder();
        ResultSet rs;
        ConexionAvw c = new ConexionAvw();
        sql.append("select faw_codigo from fotos_articulos_web");
        try{
            c.abrirConexion();
            rs = c.getPreparedStatementResultSet(sql, null);
            while (rs.next()){
                String urlOrigen = "Especificar url de la carpeta que contiene las imagenes"+ rs.getString("faw_codigo")+"completar nombre de la imagen(_original.jpg)";
                File origen = new File(urlOrigen);
                if (!origen.exists()){
                    urlOrigen = "Especificar url de la carpeta que contiene las imagenes"+ rs.getString("faw_codigo")+"completar otro posible nombre de la imagen(_alta.jpg)";
                    origen = new File(urlOrigen);
                }
                if (origen.exists()){
                    String urlDestino = "Especificar url de la carpeta destino de las imagenes " + rs.getString("faw_codigo");

                    util.Archivos.dimensionarImagen(origen,urlDestino + "_70x70.jpg","70", "70");//Foto utilizada en Jmaki 

                    util.Archivos.dimensionarImagen(origen,urlDestino + "_90x90.jpg","90", "90");//Foto utilizada en Jmaki 

                    util.Archivos.dimensionarImagen(origen,urlDestino + "_120x120.jpg","120", "120");//Foto en el home y listar 

                    util.Archivos.dimensionarImagen(origen,urlDestino + "_200x200.jpg","200", "200");//Foto utilizada en articulo

                    util.Archivos.dimensionarImagen(origen,urlDestino + "_400x400.jpg","400", "400");//Foto utilizada en articulo ver mas
                    
                    util.Archivos.dimensionarImagen(origen,urlDestino + "_original.jpg","", "");//Foto original
                }
            }
            
            
        }catch(Exception e){
        }finally{
            c.cerrarConexion();
        }
    }
}
